﻿//using System;
//using System.Collections.Generic;
//using System.Linq;
//using System.Text;
//using System.Threading.Tasks;

//namespace Tetris.Game.Common.Algorithm
//{
//    public class TetrisAI2
//    {
//        private const int Width = 10;
//        private const int Height = 20;

//        public (int, int, int) ChooseBestMove(Tetromino piece, int[,] grid)
//        {
//            int bestScore = int.MinValue;
//            int bestX = 0;
//            int bestY = 0;
//            int bestRotation = 0;
//            Tetromino testPiece = new Tetromino(piece.Type);

//            for (int rotation = 0; rotation < 4; rotation++)
//            {
//                // 旋转
//                testPiece.Rotation = rotation;
//                for (int x = 0; x < Width; x++)
//                {
//                    testPiece.X = x;
//                    testPiece.Y = 0;

//                    if (CanPlace(testPiece, grid))
//                    {
//                        int y = DropHeight(testPiece, grid);
//                        testPiece.Y = y;
//                        int score = EvaluatePosition(testPiece, grid);

//                        if (score > bestScore)
//                        {
//                            bestScore = score;
//                            bestX = testPiece.X;
//                            bestY = testPiece.Y;
//                            bestRotation = rotation;
//                        }
//                    }
//                }
//            }

//            return (bestX, bestY, bestRotation);
//        }

//        private bool CanPlace(Tetromino piece, int[,] grid)
//        {
//            foreach (var (dx, dy) in piece.GetCoordinates())
//            {
//                int newX = piece.X + dx;
//                int newY = piece.Y + dy;
//                if (newX < 0 || newX >= Width || newY < 0 || newY >= Height || grid[newY, newX] != 0)
//                {
//                    return false;
//                }
//            }
//            return true;
//        }
//        /// <summary>
//        /// 落差高度
//        /// </summary>
//        /// <param name="piece"></param>
//        /// <param name="grid"></param>
//        /// <returns></returns>
//        private int DropHeight(Tetromino piece, int[,] grid)
//        {
//            int y = piece.Y;
//            while (CanMove(piece, grid, 0, y + 1))
//            {
//                y++;
//            }
//            return y;
//        }

//        private bool CanMove(Tetromino piece, int[,] grid, int dx, int dy)
//        {
//            return CanPlace(new Tetromino(piece.Type) { X = piece.X + dx, Y = piece.Y + dy, Rotation = piece.Rotation }, grid);
//        }
//        /// <summary>
//        /// 计算得分
//        /// </summary>
//        /// <param name="piece"></param>
//        /// <param name="grid"></param>
//        /// <returns></returns>
//        private int EvaluatePosition(Tetromino piece, int[,] grid)
//        {
//            int[,] tempGrid = (int[,])grid.Clone();
//            MergePieceToGrid(piece, tempGrid);

//            int score = 0;
//            score += CountCompleteLines(tempGrid) * 100;       // High reward for clearing lines
//            score -= CalculateHoles(tempGrid) * 10;            // Penalty for creating holes
//            score -= CalculateCumulativeHeights(tempGrid) * 1; // Smaller penalty for height
//            score -= CalculateBumpiness(tempGrid) * 5;         // Penalty for bumpiness

//            return score;
//        }
//        /// <summary>
//        /// 将饼图合并到网格
//        /// </summary>
//        /// <param name="piece"></param>
//        /// <param name="grid"></param>
//        private void MergePieceToGrid(Tetromino piece, int[,] grid)
//        {
//            foreach (var (dx, dy) in piece.GetCoordinates())// 获取坐标
//            {
//                grid[piece.Y + dy, piece.X + dx] = 1;
//            }
//        }
//        /// <summary>
//        /// 计数完整行
//        /// </summary>
//        /// <param name="grid"></param>
//        /// <returns></returns>
//        private int CountCompleteLines(int[,] grid)
//        {
//            int completeLines = 0;
//            for (int y = 0; y < Height; y++)
//            {
//                bool isComplete = true;
//                for (int x = 0; x < Width; x++)
//                {
//                    if (grid[y, x] == 0)
//                    {
//                        isComplete = false;
//                        break;
//                    }
//                }
//                if (isComplete)
//                {
//                    completeLines++;
//                }
//            }
//            return completeLines;
//        }
//        /// <summary>
//        /// 计算孔
//        /// </summary>
//        /// <param name="grid"></param>
//        /// <returns></returns>
//        private int CalculateHoles(int[,] grid)
//        {
//            int holes = 0;
//            for (int x = 0; x < Width; x++)
//            {
//                bool blockFound = false;
//                for (int y = 0; y < Height; y++)
//                {
//                    if (grid[y, x] == 1)
//                    {
//                        blockFound = true;
//                    }
//                    else if (blockFound && grid[y, x] == 0)
//                    {
//                        holes++;
//                    }
//                }
//            }
//            return holes;
//        }
//        /// <summary>
//        /// 计算累计高度
//        /// </summary>
//        /// <param name="grid"></param>
//        /// <returns></returns>
//        private int CalculateCumulativeHeights(int[,] grid)
//        {
//            int totalHeight = 0;
//            for (int x = 0; x < Width; x++)
//            {
//                for (int y = 0; y < Height; y++)
//                {
//                    if (grid[y, x] == 1)
//                    {
//                        totalHeight += (Height - y);
//                        break;
//                    }
//                }
//            }
//            return totalHeight;
//        }
//        /// <summary>
//        /// 计算凹凸
//        /// </summary>
//        /// <param name="grid"></param>
//        /// <returns></returns>
//        private int CalculateBumpiness(int[,] grid)
//        {
//            int bumpiness = 0;
//            int lastHeight = 0;
//            for (int x = 0; x < Width; x++)
//            {
//                int currentHeight = 0;
//                for (int y = 0; y < Height; y++)
//                {
//                    if (grid[y, x] == 1)
//                    {
//                        currentHeight = Height - y;
//                        break;
//                    }
//                }
//                if (x > 0)
//                {
//                    bumpiness += Math.Abs(currentHeight - lastHeight);
//                }
//                lastHeight = currentHeight;
//            }
//            return bumpiness;
//        }
//    }
//}
